Multicore processors rely on atomicity to guarantee correctness of parallel applications. To prevent other processes from interrupting the execution of atomic operations, one implemented solution is for the processes to obtain locks on the resources needed to execute the critical section in mutual-exclusion so that other processes are prevented from using the same resources until the resources are released from the locks. An example of one such lock is a spinlock. A spinlock is an atomic operation that actively waits until the lock is acquired, repeatedly checking whether the lock is available. Since the spinlock process remains active but is not performing a useful task, this active wait operation consumes energy because the processor is continuously loading the lock from memory. Other locks, or other resource acquisition schemes, may similarly be associated with some cost to the efficiency and performance of the implementing device. To save energy, some processor architectures have instructions to wait for events and to signal events (e.g., ARM wait-for-event (“WFE”)/set event (“SEV”)). These architectures employ these instructions in an indiscriminate manner, where the instructions are broadcast to all waiting processor cores and create a race condition between the processor cores to claim an available lock for executing the critical sections.
When signaling a processor core with a wake up instruction to execute an atomic process, some operating systems, such as Linux, reorder the wake up in software to avoid cache ping-pong issues. In these instances operating system level handling may require kernel activity and context switches. This may result in reduced performance and increased resource usage in an architecture employing the above described indiscriminant instruction signaling in which multiple processor cores would be signaled to wake up to obtain an available lock when only one core will be able to use the resource.